package com.ruoyi.service.impl;

import java.util.List;
import java.util.ArrayList;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.domain.Water;
import com.ruoyi.mapper.ConlumnMapper;
import com.ruoyi.mapper.WaterMapper;
import com.ruoyi.service.IConlumnService;
import org.apache.ibatis.annotations.Param;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ruoyi.mapper.ConlumnMapper;
import com.ruoyi.domain.Conlumn;
import com.ruoyi.service.IConlumnService;
import com.ruoyi.system.mapper.SysDeptMapper;
import com.ruoyi.service.IColumnPermissionService;
import com.ruoyi.domain.ColumnPermission;

/**
 * 栏目管理Service业务层处理
 * 
 * @author ruoyi
 * @date 2025-01-25
 */
@Service
public class ConlumnServiceImpl extends ServiceImpl<ConlumnMapper, Conlumn> implements IConlumnService
{
    @Autowired
    private ConlumnMapper conlumnMapper;

    @Autowired
    private SysDeptMapper sysDeptMapper;
    
    @Autowired
    private IColumnPermissionService columnPermissionService;

    @Override
    public List<Conlumn> selectConlumnListByRole(boolean isAdmin, Long deptId, Conlumn conlumn) {
        if (isAdmin) {
            return conlumnMapper.selectConlumnListByRole(isAdmin, deptId, conlumn);
        }
        
        // 获取实际用于权限检查的部门ID
        Long permissionDeptId = getPermissionDeptId(deptId);
        
        // 使用权限部门ID查询栏目列表
        return conlumnMapper.selectConlumnListByRole(isAdmin, permissionDeptId, conlumn);
    }
    
    /**
     * 判断部门是否直接隶属于荆州市长江河道管理局（一级子部门）
     * @param dept 部门信息
     * @return 是否直接隶属于荆州市长江河道管理局
     */
    private boolean isDirectSubDeptOfJingZhou(com.ruoyi.common.core.domain.entity.SysDept dept) {
        // 如果部门本身就是"荆州市长江河道管理局"，则不认为是其下级部门
        if ("荆州市长江河道管理局".equals(dept.getDeptName())) {
            return false;
        }
        
        // 直接检查父部门是否为"荆州市长江河道管理局"
        // 如果父部门ID有效，直接查询父部门名称
        if (dept.getParentId() != null && dept.getParentId() > 0) {
            com.ruoyi.common.core.domain.entity.SysDept parentDept = sysDeptMapper.selectDeptById(dept.getParentId());
            if (parentDept != null && "荆州市长江河道管理局".equals(parentDept.getDeptName())) {
                return true;
            }
        }
        
        return false;
    }
    
    /**
     * 获取用于权限检查的部门ID
     * 对于子部门，返回其父部门（分局）的ID
     * 对于分局部门，返回其自己的ID
     * @param deptId 当前部门ID
     * @return 用于权限检查的部门ID
     */
    private Long getPermissionDeptId(Long deptId) {
        // 获取部门信息
        com.ruoyi.common.core.domain.entity.SysDept dept = sysDeptMapper.selectDeptById(deptId);
        if (dept == null) {
            return deptId;
        }
        
        // 如果是直接隶属于荆州市长江河道管理局的部门（分局），直接返回自己的ID
        if (isDirectSubDeptOfJingZhou(dept)) {
            return deptId;
        }
        
        // 对于子部门，查找其父部门（分局）
        if (dept.getAncestors() != null && !dept.getAncestors().isEmpty()) {
            // 从 ancestors 中提取所有祖先部门ID
            String[] ancestorIds = dept.getAncestors().split(",");
            
            // 从后往前查找（越靠近自己越优先），找到直接隶属于荆州市长江河道管理局的祖先部门（分局）
            for (int i = ancestorIds.length - 1; i >= 0; i--) {
                String ancestorId = ancestorIds[i];
                if (!ancestorId.trim().isEmpty()) {
                    try {
                        Long ancestorDeptId = Long.parseLong(ancestorId.trim());
                        com.ruoyi.common.core.domain.entity.SysDept ancestorDept = sysDeptMapper.selectDeptById(ancestorDeptId);
                        // 检查祖先部门是否直接隶属于荆州市长江河道管理局
                        if (ancestorDept != null && ancestorDept.getDeptName() != null &&
                                isDirectSubDeptOfJingZhou(ancestorDept)) {
                            return ancestorDeptId;
                        }
                    } catch (NumberFormatException e) {
                        // 忽略无效ID
                    }
                }
            }
        }
        
        // 如果没有找到分局作为父部门，返回原始部门ID
        return deptId;
    }

    /**
     * 查询栏目管理
     * 
     * @param id 栏目管理主键
     * @return 栏目管理
     */
    @Override
    public Conlumn selectConlumnById(Long id)
    {
        return conlumnMapper.selectConlumnById(id);
    }

    /**
     * 查询栏目管理列表
     *
     * @param conlumn 栏目管理
     * @return 栏目管理
     */
    @Override
    public List<Conlumn> selectConlumnList(Conlumn conlumn)
    {
        return conlumnMapper.selectConlumnList(conlumn);
    }

    /**
     * 新增栏目管理
     * 
     * @param conlumn 栏目管理
     * @return 结果
     */
    @Override
    public int insertConlumn(Conlumn conlumn)
    {
        return conlumnMapper.insertConlumn(conlumn);
    }

    /**
     * 修改栏目管理
     * 
     * @param conlumn 栏目管理
     * @return 结果
     */
    @Override
    public int updateConlumn(Conlumn conlumn)
    {
        return conlumnMapper.updateConlumn(conlumn);
    }

    /**
     * 批量删除栏目管理
     * 
     * @param ids 需要删除的栏目管理主键
     * @return 结果
     */
    @Override
    public int deleteConlumnByIds(Long[] ids)
    {
        return conlumnMapper.deleteConlumnByIds(ids);
    }

    /**
     * 删除栏目管理信息
     * 
     * @param id 栏目管理主键
     * @return 结果
     */
    @Override
    public int deleteConlumnById(Long id)
    {
        return conlumnMapper.deleteConlumnById(id);
    }

    @Override
    public boolean existsChildByParentId(Long id) {
        if(conlumnMapper.existsChildByParentId(id)>0){
            return true;
        }
        return false;
    }
}
